<!DOCTYPE html>
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
	<title>基础知识</title>
	<link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.6/css/bootstrap.min.css"" rel="stylesheet">
	<link href="https://cdn.bootcdn.net/ajax/libs/animate.css/3.2.3/animate.css" rel="stylesheet">
	<link href="https://cdn.bootcdn.net/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet">
	<link rel="stylesheet" type="text/css" href="../../static/css/public.css" />
	<style type="text/css">
		li{
			text-indent: 2em;
			list-style: none;
		}
		li~li{
			margin-top: 15px;
		}
	</style>
</head>
<body>
	<!-- 回到顶部 -->
	<div class="topBtn">
		<a href="#top">
			<i class="fa fa-long-arrow-up"></i>
		</a>
	</div>
	<!--右边内容-->
	<div id="app" class="main animated fadeInRight">
		<div class="shadow">
			<div>
				<h3>判断数据类型</h3>
			</div>
			<div class="Table" v-cloak id="top">
				<div class="TableRow" v-for="(el,index) in list">
					<a class="RowLeft" :href="'#'+el.id">{{el.name}}</a>
					<span class="RowRight">{{el.explain}}</span>
				</div>
			</div>
			<div>
				<h4 id="typeof">typeof</h4>
				<p>判断数据类型常用的方式是 typeof ,但是对于数组和 null 的判断不准。
					但对于原始类型来说，除了 null 都可以显示正确的类型</p>
				<pre>
	typeof 　　undefined　　		'undefined'
	typeof 　　null 　　　　 	'object'
	typeof 　　true 　　　　 	'boolean'
	typeof 　　123 　　　　　	'number'
	typeof 　　"abc" 　　　　	'string'
	typeof 　　function(){} 	'function'
	typeof 　　{} 　　　　　　	'object'
	typeof 　　[] 　　　　　　	'object'
				</pre>
			</div>
			<div>
				<h4 id="array">判断数组</h4>
				<pre>
	1、Array.isArray()  //ES6方法
	var a = [];
	Array.isArray(a); // true
	
	2、constructor属性	(不推荐，如果创建一个对象，更改它的原型，constructor就会变得不可靠了)
	var a = [];
	a.constructor === Array // true
	
	function Fn(){};
	Fn.prototype=new Array();
	var f=new Fn();
	 
	console.log(f.constructor===Fn);    // false
	console.log(f.constructor===Array); // true 

	
	3、instanceof (可判断 Arrray、Object。不推荐)
	var a =[];
	a instanceof Array // true
	
	4、$.isPlainObject() 
	var a = {}; // 或 var a = new Object();
	$.isPlainObject(a) // true
	
	5、Object.prototype.toString.call()   (推荐)
	var arr= []
	console.log( Object.prototype.toString.call(arr));=>"[object Array]"
				</pre>
			</div>
			<div>
				<h4 id="instanceof">instanceof</h4>
				<div>instanceof可以精准判断引用数据类型（Array，Function，Object），
				而基本数据类型不能被instanceof精准判断。instanceof 是用来判断 A 是否为 B 的实例， 
				表达式为：A instanceof B，如果 A 是 B 的实例，
				则返回 true,否则返回 false。 注意：instanceof()检测的是原型,修改后不能准确判断</div>
				<pre>
	[] instanceof Array; //true
	{} instanceof Object;//true
	new Date() instanceof Date;//true
	console.log(2 instanceof Number);                    // false
	console.log(true instanceof Boolean);                // false 
	console.log('str' instanceof String);                // false  
	console.log([] instanceof Array);                    // true
	console.log(function(){} instanceof Function);       // true
	console.log({} instanceof Object);                   // true    
	// console.log(undefined instanceof Undefined);
	// console.log(null instanceof Null);
				
				</pre>
				<p>
					instanceof 运算符用来
					<span class="red">测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性</span>。
					其意思就是判断对象是否是某一数据类型（如Array）的实例，
					请重点关注一下是判断一个对象是否是数据类型的实例。在这里字面量值，2， true ，
					'str'不是实例，所以判断值为false。
				</p>
			</div>
			<div>
				<h4 id="compail">valueOf与toString</h4>
				<p>
					valueOf与toString通常用来值的转化，主要区别如下
				</p>
				<pre>
	{}.valueOf() ===>{} ，{}.toString()===>"[object Object]"
	
	[].valueOf() ===>[] ，[].toString() ===>""
			
				</pre>
				<div>Object.prototype.toString</div>
				<p>
					toString()是 Object 的原型方法，调用该方法，默认返回当前对象的[[class]]。
					这是一个内部属性，其格式为[object Xxx]，其中 Xxx 就是对象的类型。
					对于 Object 对象，直接调用toString()就能返回[object Object]。
					而对于其他对象，则需要通过call / apply来调用才能返回正确的类型信息。
				</p>
				<ul>
					<li>Object.prototype.toString.call('') ;   // [object String]</li>
					<li>Object.prototype.toString.call(1) ;    // [object Number]</li>
					<li>Object.prototype.toString.call(true) ; // [object Boolean]</li>
					<li>Object.prototype.toString.call(Symbol()); //[object Symbol]</li>
					<li>Object.prototype.toString.call(undefined) ; // [object Undefined]</li>
					<li>Object.prototype.toString.call(null) ; // [object Null]</li>
					<li>Object.prototype.toString.call(newFunction()) ; // [object Function]</li>
					<li>Object.prototype.toString.call(newDate()) ; // [object Date]</li>
					<li>Object.prototype.toString.call([]) ; // [object Array]</li>
					<li>Object.prototype.toString.call(newRegExp()) ; // [object RegExp]</li>
					<li>Object.prototype.toString.call(newError()) ; // [object Error]</li>
					<li>Object.prototype.toString.call(document) ; // [object HTMLDocument]</li>
					<li>Object.prototype.toString.call(window) ; //[object global] window 是全局对象 global 的引用</li>
				</ul>
			</div>
			<div>
				<h4 id="constructor">constructor</h4>
				<p>
					当一个函数F被定义时，JS引擎会为F添加prototype 原型，
					然后再在prototype上添加一个 constructor 属性，并让其指向 F 的引用。
					当执行var f = new F()时，F被当成了构造函数，f是F的实例对象，
					此时F原型上的 constructor 传递到了f上，因此f.constructor == F.
					当执行 var f = new F() 时，F 被当成了构造函数，f 是F的实例对象，
					此时 F 原型上的 constructor 传递到了 f 上，因此 f.constructor == F
				</p>
			</div>
		</div>
	</div>
	<!--页面加载进度条-->
	<script src="https://cdn.bootcdn.net/ajax/libs/pace/0.5.0/pace.min.js"></script>
	<script src="https://cdn.bootcdn.net/ajax/libs/vue/2.5.17/vue.js" type="text/javascript" charset="utf-8"></script>
	<script type="text/javascript">
		var app = new Vue({
			el: "#app",
			data: function() {
				return {
					list: [
						{ name: "typeof",id: "typeof",explain: ''},
						{ name: "判断数组",id: "array",explain: ''},
						{ name: "instanceof",id: "instanceof",explain: ''},
						{ name: "valueOf与toString",id: "compail",explain: 'Object.prototype.toString判断类型，推荐'},
						{ name: "constructor",id: "constructor",explain: ''},
					]
				}
			},
			mounted() {
			}
		})
	</script>
</body>

</html>